home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / video / xevil-1.000 / xevil-1 / intel.C < prev    next >
C/C++ Source or Header  |  1995-07-24  |  27KB  |  1,304 lines
  1. // "intel.C"
  2.  
  3. /*    Copyright (C) 1994  Steve Hardt
  4.  
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 1, or (at your option)
  8.     any later version.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19.     Steve Hardt 
  20.     hardts@athena.mit.edu hardts@media.mit.edu
  21.     hardts@r4002.3dem.bioch.bcm.tmc.edu
  22.     2043 McClendon
  23.     Houston, TX 77030
  24. */
  25.  
  26. #ifndef NO_PRAGMAS
  27. #pragma implementation "intel.h"
  28. #endif
  29.  
  30.  
  31. // Include Files
  32. extern "C" {
  33.   #include <string.h>
  34. }
  35.  
  36. #include "utils.h"
  37. #include "physical.h"
  38. #include "intel.h"
  39. #include "actual.h"
  40.  
  41.  
  42.  
  43. // Defines
  44. #define TARGET_RANGE 500
  45. #define REFLEXES_TIME 4
  46. #define FIGHT_RANGE 45  // [50-40]
  47. #define FIGHT_RANGE_2 (FIGHT_RANGE * FIGHT_RANGE)
  48. #define WANDER_WIDTH 1000
  49. #define WANDER_HEIGHT 600
  50. #define SHOT_CUTOFF 9
  51. #define LADDER_JUMP_TIME 4
  52. #define FTHROWER_RANGE_2 (90 * 90)
  53. #define HEALTH_ATTACK_PERCENT .1
  54. #define TRANSMOGIFIER_PERCENT .15
  55. #define MASTER_MIN_DIST 50
  56. #define MASTER_MIN_DIST_2 (MASTER_MIN_DIST * MASTER_MIN_DIST)
  57. #define MASTER_MAX_DIST 350 
  58. #define MASTER_MAX_DIST_2 (MASTER_MAX_DIST * MASTER_MAX_DIST)
  59. // Strategy change times for different strategies.
  60. #define TO_AWAY_TARGET_TIME 30
  61. #define TO_POS_TIME 100
  62. #define TO_MASTER_TIME 100
  63.  
  64.  
  65. const IntelOptions Intel::intelOptionsDefault = 
  66. {
  67.   True, // classFriends
  68.   False, // harmless
  69.   False, // psychotic
  70.   False, // ignoreItems
  71.   False, // ignoreLemmings
  72. };
  73.  
  74.  
  75.  
  76. Intel::Intel(WorldP w,LocatorP l,char *name,int lives,
  77.          const IntelOptions *ops,ITmask opMask)
  78. {
  79.   intelStatusChanged = True;
  80.   living = True;
  81.   world = w;
  82.   locator = l;
  83.  
  84.   intelOptions = intelOptionsDefault;
  85.   if (opMask & ITharmless)
  86.     intelOptions.harmless = ops->harmless;
  87.   if (opMask & ITclassFriends)
  88.     intelOptions.classFriends = ops->classFriends;
  89.   if (opMask & ITpsychotic)
  90.     intelOptions.psychotic = ops->psychotic;
  91.   if (opMask & ITignoreItems)
  92.     intelOptions.ignoreItems = ops->ignoreItems;
  93.   if (opMask & ITignoreLemmings)
  94.     intelOptions.ignoreLemmings = ops->ignoreLemmings;
  95.  
  96.   // intelStatus
  97.   strcpy(intelStatus.name,name);
  98.   intelStatus.classId = A_None;
  99.   strcpy(intelStatus.clas,"none");
  100.   intelStatus.health = 0;
  101.   intelStatus.mass = 0;
  102.   intelStatus.weaponClassId = A_None;
  103.   strcpy(intelStatus.weapon,"none");
  104.   intelStatus.weaponReady = False;
  105.   intelStatus.ammo = PH_AMMO_UNLIMITED;
  106.   intelStatus.itemClassId = A_None;
  107.   strcpy(intelStatus.item,"none");
  108.   if (lives != IT_INFINITE_LIVES)
  109.     intelStatus.lives = lives - 1; // One life is used for current life.  
  110.   else 
  111.     intelStatus.lives = IT_INFINITE_LIVES;
  112.   intelStatus.humanKills = 0;
  113.   intelStatus.enemyKills = 0;
  114.   intelStatus.soups = 0;
  115. }
  116.  
  117.  
  118.  
  119. Boolean Intel::is_human()
  120. {
  121.   return False;
  122. }
  123.  
  124.  
  125. Boolean Intel::is_enemy()
  126. {
  127.   return False;
  128. }
  129.  
  130.  
  131.  
  132. Boolean Intel::is_lemming_intel()
  133. {
  134.   return False;
  135. }
  136.  
  137.  
  138.  
  139. Boolean Intel::reincarnate_me()
  140. {
  141.   return !living && 
  142.     (intelStatus.lives == IT_INFINITE_LIVES || intelStatus.lives > 0);
  143. }
  144.  
  145.  
  146.  
  147. void Intel::add_human_kill()
  148. {
  149.   intelStatus.humanKills++; 
  150.   intelStatusChanged = True;
  151. }
  152.  
  153.  
  154.  
  155. void Intel::add_enemy_kill()
  156. {
  157.   intelStatus.enemyKills++; 
  158.   intelStatusChanged = True;
  159. }
  160.  
  161.  
  162.  
  163. void Intel::add_soup()
  164. {
  165.   intelStatus.soups++; 
  166.   intelStatusChanged = True;
  167. }
  168.  
  169.  
  170.  
  171. ITcommand Intel::dir_to_command(Dir dir)
  172. {
  173.   assert(dir == CO_air || dir >= CO_R);
  174.   ITcommand ret = IT_CENTER;
  175.   if (dir != CO_air)
  176.     ret = (ITcommand)((dir - CO_R) * 0.5 + IT_R);
  177.   
  178.   return ret;
  179. }
  180.  
  181.  
  182.  
  183. ITcommand Intel::dir_to_command_weapon(Dir dir)
  184. {
  185.   assert(dir == CO_air || dir >= CO_R);
  186.   ITcommand ret = IT_WEAPON_CENTER;
  187.   if (dir != CO_air)
  188.     ret = (ITcommand)((dir - CO_R) * 0.5 + IT_WEAPON_R);
  189.   
  190.   return ret;
  191. }
  192.  
  193.  
  194.  
  195. Dir Intel::command_weapon_to_dir_4(ITcommand command)
  196. {
  197.   switch (command) {
  198.   case IT_WEAPON_R:
  199.     return CO_R;
  200.   case IT_WEAPON_DN:
  201.     return CO_DN;
  202.   case IT_WEAPON_L:
  203.     return CO_L;
  204.   case IT_WEAPON_UP:
  205.     return CO_UP;
  206.   };
  207.   
  208.   return CO_air;
  209. }
  210.  
  211.  
  212.  
  213. Dir Intel::command_weapon_to_dir_8(ITcommand command)
  214. {
  215.   switch (command) {
  216.   case IT_WEAPON_R:
  217.     return CO_R;
  218.   case IT_WEAPON_DN_R:
  219.     return CO_DN_R;
  220.   case IT_WEAPON_DN:
  221.     return CO_DN;
  222.   case IT_WEAPON_DN_L:
  223.     return CO_DN_L;
  224.   case IT_WEAPON_L:
  225.     return CO_L;
  226.   case IT_WEAPON_UP_L:
  227.     return CO_UP_L;
  228.   case IT_WEAPON_UP:
  229.     return CO_UP;
  230.   case IT_WEAPON_UP_R:
  231.     return CO_UP_R;
  232.   };
  233.  
  234.   return CO_air;
  235. }
  236.  
  237.  
  238.  
  239.  
  240. ITcommand Intel::center_pos_to_command(const Pos &pos)
  241. {
  242.   if (pos.y > pos.x)
  243.     {
  244.       if (pos.y > -pos.x)
  245.     return IT_DN;
  246.       else 
  247.     return IT_L;
  248.     }
  249.   else
  250.     {
  251.       if (pos.y > -pos.x)
  252.     return IT_R;
  253.       else
  254.     return IT_UP;
  255.     }
  256. }
  257.  
  258.  
  259.  
  260. void Intel::die()
  261. {
  262.   intelStatus.health = -1;  
  263.   intelStatus.classId = A_None;
  264.   strcpy(intelStatus.clas,"tormented spirit");
  265.   intelStatus.mass = 0;
  266.   intelStatus.weaponClassId = A_None;
  267.   strcpy(intelStatus.weapon,"none");
  268.   intelStatus.weaponReady = False;
  269.   intelStatus.ammo = PH_AMMO_UNLIMITED;
  270.   intelStatus.itemClassId = A_None;
  271.   strcpy(intelStatus.item,"none");
  272.  
  273.   intelStatusChanged = True; 
  274.  
  275.   Id invalid;
  276.   id = invalid;
  277.   living = False;
  278. }
  279.  
  280.  
  281.  
  282. void Intel::reincarnate()
  283. {
  284.   if (intelStatus.lives != IT_INFINITE_LIVES)
  285.     {
  286.       assert (intelStatus.lives > 0);
  287.       intelStatus.lives--;
  288.       intelStatusChanged = True;
  289.     }
  290.   living = True;
  291. }
  292.  
  293.  
  294.  
  295. void Intel::clock(PhysicalP p)
  296. {
  297.   assert(intelStatus.lives == IT_INFINITE_LIVES || intelStatus.lives >= 0);
  298.   assert (p->get_id(id) == PH_NO_SIG);
  299.  
  300.   // classId, class
  301.   ClassId classId = p->get_class_id();
  302.   if (classId != intelStatus.classId)
  303.     {
  304.       intelStatus.classId = classId;
  305.       strcpy(intelStatus.clas,p->identify());
  306.       intelStatusChanged = True;
  307.     }
  308.  
  309.   // health
  310.   Health health = p->get_health();
  311.   if ((health >= 0) && (health != intelStatus.health))
  312.     {
  313.       intelStatus.health = health;
  314.       intelStatusChanged = True;
  315.     }
  316.   
  317.   // mass
  318.   Mass mass = p->get_mass();
  319.   if (mass != intelStatus.mass)
  320.     {
  321.       intelStatus.mass = mass;
  322.       intelStatusChanged = True;
  323.     }
  324.  
  325.  
  326.   if (p->is_user())
  327.     {
  328.       PhysicalP user = p;
  329.  
  330.       // weaponClassId, weapon
  331.       PhysicalP weapon = user->get_weapon_current();
  332.       ClassId weaponClassId = weapon ? weapon->get_class_id() : A_None;
  333.       if (intelStatus.weaponClassId != weaponClassId)
  334.     {
  335.       intelStatus.weaponClassId = weaponClassId;
  336.       strcpy(intelStatus.weapon,weapon ? weapon->identify() : "none");
  337.       intelStatusChanged = True;
  338.     }
  339.  
  340.       // weaponReady
  341.       Boolean weaponReady = weapon ? ((WeaponP)weapon)->ready() : 
  342.       (p->is_fighter() || (p->is_built_in() && p->ready()));
  343.       if (intelStatus.weaponReady != weaponReady)
  344.     {
  345.       intelStatus.weaponReady = weaponReady;
  346.       intelStatusChanged = True;
  347.     }
  348.  
  349.       // ammo
  350.       int ammo = weapon ? ((WeaponP)weapon)->get_ammo() : PH_AMMO_UNLIMITED;
  351.       if (intelStatus.ammo != ammo)
  352.     {
  353.       intelStatus.ammo = ammo;
  354.       intelStatusChanged = True;
  355.     }
  356.       
  357.       // itemClassId, item
  358.       PhysicalP item = user->get_item_current();
  359.       ClassId itemClassId = item ? item->get_class_id() : A_None;
  360.       if (intelStatus.itemClassId != itemClassId)
  361.     {
  362.       intelStatus.itemClassId = itemClassId;
  363.       strcpy(intelStatus.item,item ? item->identify() : "none");
  364.       intelStatusChanged = True;
  365.     }
  366.     }
  367.   else // Not User.
  368.     {
  369.       if (intelStatus.weaponClassId != A_None)
  370.     {
  371.       intelStatus.weaponClassId = A_None;
  372.       strcpy(intelStatus.weapon,"none");
  373.       intelStatusChanged = True;
  374.     }
  375.  
  376.       Boolean weaponReady = 
  377.     p->is_fighter() || (p->is_built_in() && p->ready());
  378.       if (intelStatus.weaponReady != weaponReady)
  379.     {
  380.       intelStatus.weaponReady = weaponReady;
  381.       intelStatusChanged = True;
  382.     }
  383.  
  384.       if (intelStatus.ammo != PH_AMMO_UNLIMITED)
  385.     {
  386.       intelStatus.ammo = PH_AMMO_UNLIMITED;
  387.       intelStatusChanged = True;
  388.     }
  389.  
  390.       if (p->is_suicide())
  391.     {
  392.       if (intelStatus.itemClassId != A_SuicideButton)
  393.         {
  394.           intelStatus.itemClassId = A_SuicideButton;
  395.           strcpy(intelStatus.item,"suicide button");
  396.           intelStatusChanged = True;
  397.         }
  398.     }
  399.       else if (intelStatus.itemClassId != A_None)
  400.     {
  401.       intelStatus.itemClassId = A_None;
  402.       strcpy(intelStatus.item,"none");
  403.       intelStatusChanged = True;
  404.     }
  405.     }
  406.  
  407.   // Kills does not depend on the physical.
  408. }
  409.  
  410.  
  411.  
  412. Human::Human(WorldP w,LocatorP l,char *name,int lives,ColorNum cNum) :
  413.        Intel(w,l,name,lives,NULL,ITnone)
  414. {
  415.   command = IT_NO_COMMAND;
  416.   colorNum = cNum;
  417. }
  418.  
  419.  
  420.  
  421. Boolean Human::is_human()
  422. {
  423.   return True;
  424. }
  425.  
  426.  
  427.  
  428. void Human::clock(PhysicalP p)
  429. { 
  430.   assert(alive());
  431.   p->set_command(command); 
  432.   command = IT_NO_COMMAND; 
  433.   Intel::clock(p);
  434. }
  435.  
  436.  
  437.  
  438. Machine::Machine(WorldP w,LocatorP l,char *name,const IntelOptions *ops,
  439.          ITmask opMask,IntelP master) 
  440. : Intel(w,l,name,1,ops,opMask)
  441. {
  442.   // strategyChange uses default initializer.
  443.   Timer mTimer(REFLEXES_TIME);
  444.   reflexes = mTimer;
  445.   Timer oTimer(LADDER_JUMP_TIME);
  446.   ladderJump = oTimer;
  447.   strategy = doNothing;
  448.   if (master)
  449.     {
  450.       masterIntelId = master->get_intel_id(); 
  451.       masterSet = True;
  452.     }
  453.   else
  454.     masterSet = False;
  455. }
  456.  
  457.  
  458.  
  459. IntelId Machine::get_master_intel_id()
  460. {
  461.   if (masterSet)
  462.     return masterIntelId;
  463.   else
  464.     {
  465.       IntelId invalid;
  466.       return invalid;
  467.     }
  468. }
  469.  
  470.  
  471.  
  472. void Machine::add_human_kill()
  473. {
  474.   if (masterSet)
  475.     {
  476.       LocatorP l = get_locator();
  477.       IntelP intel = l->lookup(masterIntelId);
  478.       if (intel)
  479.     {
  480.       intel->add_human_kill();
  481.       return;
  482.     }
  483.     }
  484.   Intel::add_human_kill();
  485. }
  486.  
  487.  
  488.  
  489. void Machine::add_enemy_kill()
  490. {
  491.   if (masterSet)
  492.     {
  493.       LocatorP l = get_locator();
  494.       IntelP intel = l->lookup(masterIntelId);
  495.       if (intel)
  496.     {
  497.       intel->add_enemy_kill();
  498.       return;
  499.     }
  500.     }
  501.   Intel::add_enemy_kill();
  502. }
  503.  
  504.  
  505.  
  506. void Machine::add_soup()
  507. {
  508.   assert(0);
  509. }
  510.  
  511.  
  512.  
  513. void Machine::clock(PhysicalP p)
  514. {
  515.   assert(alive() && p->is_creature());
  516.   const IntelOptions &ops = get_intel_options();
  517.   LocatorP locator = get_locator();
  518.   Boolean commandSet = False;
  519.   
  520.   if (reflexes.ready())
  521.     {
  522.       // Use MedKit.
  523.       if (!commandSet && 
  524.       p->is_user() && 
  525.       (p->get_health() < p->get_health_max()) && 
  526.       (has_item(p,A_MedKit)))
  527.     {
  528.       PhysicalP item = p->get_item_current();
  529.       if (item && (item->get_class_id() == A_MedKit))
  530.         p->set_command(IT_ITEM_USE);
  531.       else
  532.         p->set_command(IT_ITEM_CHANGE);
  533.       commandSet = True;
  534.     }
  535.       
  536.       // Use Transmogifier.
  537.       if (!commandSet && p->is_user() && 
  538.       (p->get_health() < TRANSMOGIFIER_PERCENT * p->get_health_max()) &&
  539.       (has_item(p,A_Transmogifier)))
  540.     {
  541.       PhysicalP item = p->get_item_current();
  542.       if (item && (item->get_class_id() == A_Transmogifier))
  543.         p->set_command(IT_ITEM_USE);
  544.       else
  545.         p->set_command(IT_ITEM_CHANGE);
  546.       commandSet = True;
  547.     }
  548.  
  549.       // Use Shield.
  550.       if (!commandSet && p->is_user() && p->is_moving() && has_shield(p))
  551.     {
  552.       PhysicalP protectionP = 
  553.         locator->lookup(((MovingP)p)->get_protection());
  554.       if (!protectionP)
  555.         {
  556.           PhysicalP item = p->get_item_current();
  557.           if (item && item->is_shield())
  558.         p->set_command(IT_ITEM_USE);
  559.           else
  560.         p->set_command(IT_ITEM_CHANGE);
  561.           commandSet = True;
  562.         }
  563.     }
  564.  
  565.       // Use Doppel.
  566.       if (!commandSet && p->is_user() && p->is_moving() && 
  567.       has_item(p,A_Doppel))
  568.     {
  569.       PhysicalP item = p->get_item_current();
  570.       if (item && item->get_class_id() == A_Doppel)
  571.         p->set_command(IT_ITEM_USE);
  572.       else
  573.         p->set_command(IT_ITEM_CHANGE);
  574.       commandSet = True;
  575.     }
  576.       
  577.  
  578.       PhysicalP target = NULL;
  579.       
  580.       // Make sure master is not to close or too far away.
  581.       PhysicalP masterP = NULL; // meaningful iff masterSet (may be NULL).
  582.       int master_dist_2; // meaningful iff (masterSet && masterP).
  583.       if (masterSet)
  584.     {
  585.       IntelP master = locator->lookup(masterIntelId);
  586.       if (master)
  587.         {
  588.           Id masterId = master->get_id();
  589.           masterP = locator->lookup(masterId);
  590.           PhysicalP p = locator->lookup(get_id());
  591.           if (masterP && p)
  592.         {
  593.           const Area &masterArea = masterP->get_area();
  594.           const Area &area = p->get_area();
  595.           Pos masterMiddle = masterArea.get_middle();
  596.           Pos middle = area.get_middle();
  597.           Size diff = masterMiddle - middle;
  598.           master_dist_2 = diff.abs_2();
  599.         }
  600.           else
  601.         masterP = NULL; // To show that master_dist_2 is invalid.
  602.         }
  603.     }
  604.  
  605.       // Wandering too far from the master.
  606.       if (masterSet && masterP && master_dist_2 > MASTER_MAX_DIST_2)
  607.     {
  608.       strategyChange.set(TO_MASTER_TIME);
  609.       strategy = toMaster;
  610.       // target = masterP;
  611.       targetId = masterP->get_id();
  612.     }
  613.  
  614.  
  615.       // New strategy.
  616.       // Make sure target is non-NULL for strategies that require it.
  617.       if (strategyChange.ready())
  618.     {
  619.       Boolean isEnemy;
  620.       target = new_target_id(isEnemy,p,masterP); // Sets targetId.
  621.       
  622.       if (target)
  623.         {
  624.           if (isEnemy)
  625.         {
  626.           if ((ops.psychotic ||
  627.                (((p->is_user() && (has_gun(p) || has_cutter(p))) ||
  628.              p->is_fighter() || 
  629.              p->is_built_in() ||
  630.              p->prickly()) &&
  631.             (p->get_health() > 
  632.              HEALTH_ATTACK_PERCENT * p->get_health_max()))) &&
  633.               !ops.harmless)
  634.             strategy = toTarget;
  635.           else
  636.             strategy = awayTarget;
  637.         }
  638.           else
  639.         strategy = toTarget;
  640.           strategyChange.set(TO_AWAY_TARGET_TIME);
  641.         }
  642.       else
  643.         strategy = doNothing;
  644.     }
  645.       else 
  646.     // Make sure that target still exists.
  647.     if (strategy == toTarget || strategy == awayTarget
  648.         || strategy == toMaster)
  649.       {
  650.         target = locator->lookup(targetId);
  651.         if (!target)
  652.           strategy = doNothing;
  653.       }
  654.  
  655.       // If no target, change strategy to toPos.
  656.       if (strategy == doNothing && !masterSet)
  657.     {
  658.       strategy = toPos;
  659.       strategyChange.set(TO_POS_TIME);
  660.       
  661.       const Area &area = p->get_area();
  662.       Pos middle = area.get_middle();
  663.       
  664.       targetPos.x = middle.x + Utils::choose(WANDER_WIDTH) - 
  665.         WANDER_WIDTH / 2;
  666.       targetPos.y = middle.y + Utils::choose(WANDER_HEIGHT) - 
  667.         WANDER_HEIGHT / 2;
  668.     }
  669.  
  670.       // If nothing better to do, go to master.
  671.       if (strategy == doNothing && masterSet && masterP)
  672.     {
  673.       strategy = toMaster;
  674.       strategyChange.set(1);
  675.       target = masterP;
  676.       targetId = masterP->get_id();
  677.     }
  678.       
  679.  
  680.       // Act on current strategy.
  681.       switch (strategy) {
  682.       case toPos:
  683.     if (!commandSet)
  684.       commandSet = move_pos(p,targetPos,ladderJump);
  685.     break;
  686.     
  687.       case toTarget:
  688.     {
  689.       assert(target);
  690.  
  691.       // Check is_creature so won't attack items.
  692.       if (!commandSet && !ops.harmless && target->is_creature())
  693.         commandSet = attack_target(p,target);
  694.       
  695.       if (!commandSet)
  696.         commandSet = move_target(p,target,ladderJump);
  697.     }
  698.     break;
  699.     
  700.       case awayTarget:
  701.     {
  702.       assert(target);
  703.  
  704.       const IntelOptions &ops = get_intel_options();
  705.       // Check is_creature so won't attack items.
  706.       if (!commandSet && !ops.harmless && target->is_creature())
  707.         commandSet = attack_target(p,target);
  708.  
  709.       if (!commandSet)
  710.         commandSet = away_target(p,target,ladderJump);
  711.     }
  712.     break;
  713.     
  714.       case toMaster:
  715.     assert(target);
  716.     if (!commandSet)
  717.       commandSet = move_target(p,target,ladderJump);
  718.     if (masterSet && masterP && master_dist_2 < MASTER_MIN_DIST_2)
  719.       strategyChange.set(1);
  720.     break;
  721.     
  722.       case doNothing:
  723.     if (!commandSet)
  724.       {
  725.         p->set_command(IT_CENTER);
  726.         commandSet = True;
  727.       }
  728.     break;
  729.       };
  730.  
  731.       reflexes.set();
  732.     }
  733.   
  734.   reflexes.clock();
  735.   strategyChange.clock();
  736.   ladderJump.clock();
  737.   Intel::clock(p);
  738. }
  739.  
  740.  
  741.  
  742. Boolean Machine::attack_target(PhysicalP p,PhysicalP target)
  743. {
  744.   // Fire a gun if available.
  745.   Boolean useGun = p->is_user() && has_gun(p);
  746.   if (useGun)
  747.     {
  748.       if (weapon_current_is_gun(p))
  749.     {
  750.       PhysicalP weapon = p->get_weapon_current();
  751.       if (weapon->ready())
  752.         {
  753.           const Area &area = p->get_area();
  754.           Pos pos = area.get_middle();
  755.           const Area &targetArea = target->get_area();
  756.           Pos targetPos = targetArea.get_middle();
  757.           
  758.           Size rel = targetPos - pos;
  759.           Boolean distOk = True;
  760.           
  761.           if (weapon->get_class_id() == A_FThrower)
  762.         distOk = rel.abs_2() < FTHROWER_RANGE_2;
  763.           
  764.           if (distOk)
  765.         {
  766.           Dir weaponDir = rel.get_dir();
  767.           
  768.           const Vel *unitVels = p->get_unit_vels();
  769.           float z = rel.cross(unitVels[weaponDir]);
  770.               
  771.           if (fabs(z) <= SHOT_CUTOFF)
  772.             {
  773.               p->set_command(dir_to_command_weapon(weaponDir));
  774.               return True;
  775.             }
  776.         }
  777.         }
  778.     }
  779.       else /* if (weapon_current_is_gun(p)) */
  780.     {
  781.       p->set_command(IT_WEAPON_CHANGE);
  782.       return True;
  783.     }
  784.     } /* if (useGun) */
  785.   
  786.   
  787.   // Use cutter if available.
  788.   Boolean useCutter = !useGun && p->is_user() && has_cutter(p);
  789.   if (useCutter)
  790.     {
  791.       if (!weapon_current_is_cutter(p))
  792.     {
  793.       p->set_command(IT_WEAPON_CHANGE);
  794.       return True;
  795.     }
  796.       // else move toward target.
  797.     }
  798.   
  799.  
  800.   // Use built in weapon if available.
  801.   Boolean useBuiltIn = !useGun && !useCutter && p->is_built_in();
  802.   if (useBuiltIn)
  803.     {
  804.       if (!p->get_weapon_current())
  805.     {
  806.       if (p->ready())
  807.         {
  808.           const Area &area = p->get_area();
  809.           Pos pos = area.get_middle();
  810.           const Area &targetArea = target->get_area();
  811.           Pos targetPos = targetArea.get_middle();
  812.           
  813.           Size rel = targetPos - pos;
  814.           Dir weaponDir = rel.get_dir();
  815.           const Vel *unitVels = p->get_unit_vels();
  816.           float z = rel.cross(unitVels[weaponDir]);
  817.               
  818.           if (fabs(z) <= SHOT_CUTOFF)
  819.         {
  820.           p->set_command(dir_to_command_weapon(weaponDir));
  821.           return True;
  822.         }
  823.         }
  824.     }
  825.       else
  826.     {
  827.       p->set_command(IT_WEAPON_CHANGE);
  828.       return True;
  829.     }
  830.     }
  831.  
  832.   
  833.   // Close range fighting
  834.   if (!useGun && !useCutter && !useBuiltIn && p->is_fighter())
  835.     {
  836.       if (!p->get_weapon_current())
  837.     {
  838.       const Area &area = p->get_area();
  839.       const Area &targetArea = target->get_area();
  840.       const Pos middle = area.get_middle();
  841.       const Pos targetMiddle = targetArea.get_middle();
  842.       
  843.       if (middle.distance_2(targetMiddle) <= FIGHT_RANGE_2)
  844.         {
  845.           //  Dir dirTo = area.dir_to(targetArea);
  846.           Size rel = targetMiddle - middle;
  847.           Dir dirTo = rel.get_dir();
  848.  
  849.           p->set_command(dir_to_command_weapon(dirTo));
  850.           return True;
  851.         }
  852.     }
  853.       else
  854.     {
  855.       p->set_command(IT_WEAPON_CHANGE);
  856.       return True;
  857.     }
  858.     }
  859.  
  860.  
  861.   return False;
  862. }
  863.  
  864.  
  865.  
  866.  
  867. Boolean Machine::move_target(PhysicalP physical,PhysicalP target,
  868.                  Timer &ladderJump)
  869. {
  870.   const Area &area = physical->get_area();
  871.   Dir toTarget = area.dir_to(target->get_area());
  872.   
  873.   return move_dir(physical,toTarget,ladderJump);
  874. }
  875.  
  876.  
  877.  
  878. Boolean Machine::away_target(PhysicalP physical,PhysicalP target,
  879.                  Timer &ladderJump)
  880. {
  881.   const Area &area = physical->get_area();
  882.   Dir awayTarget = Coord::dir_opposite(area.dir_to(target->get_area()));
  883.   
  884.   return move_dir(physical,awayTarget,ladderJump);
  885. }
  886.  
  887.  
  888.  
  889. Boolean Machine::move_pos(PhysicalP physical,const Pos &targetPos,
  890.               Timer &ladderJump)
  891. {
  892.   const Area &area = physical->get_area();
  893.   Dir toPos = area.dir_to(targetPos);
  894.  
  895.   return move_dir(physical,toPos,ladderJump);
  896. }
  897.  
  898.  
  899.  
  900. Boolean Machine::move_dir(PhysicalP physical,Dir dir,
  901.               Timer &ladderJump)
  902. {
  903.   assert(physical->is_creature());
  904.   CreatureP creature = (CreatureP) physical;
  905.   ITcommand command = IT_NO_COMMAND;
  906.   
  907.   if (creature->is_flying())
  908.     command = dir_to_command(dir);
  909.   else // Sticky, Walking, Grounded, Hopping
  910.     {
  911.       Stance stance = creature->get_stance();
  912.       Touching touching = creature->get_touching_area();
  913.       const Hanging &hanging = creature->get_hanging();
  914.       Boolean canClimb = creature->can_climb();
  915.       
  916.       switch (dir) {
  917.       case CO_R:
  918.     switch (stance) {
  919.     case CO_center:
  920.     case CO_dn:
  921.     case CO_l:
  922.     case CO_up:
  923.       if ((touching != CO_R) || creature->is_sticky())
  924.         command = IT_R;
  925.       break;
  926.     case CO_climb:
  927.       if ((touching != CO_R) || creature->is_sticky())
  928.         {
  929.           command = IT_UP_R;
  930.           ladderJump.set();
  931.         }
  932.       break;
  933.     };
  934.     break;
  935.     
  936.       case CO_DN_R:
  937.     if (canClimb && touching != CO_dn && ladderJump.ready())
  938.       {
  939.         command = IT_DN;
  940.         break;
  941.       }
  942.     switch (stance) {
  943.     case CO_center:
  944.     case CO_dn:
  945.     case CO_up:
  946.       command = IT_R;
  947.       break;
  948.     case CO_r:
  949.       command = IT_DN;
  950.       break;
  951.     case CO_l:
  952.       command = IT_DN_R;
  953.       break;
  954.     case CO_climb:
  955.       if (touching != CO_dn)
  956.         command = IT_DN;
  957.       else
  958.         {
  959.           command = IT_R;
  960.           ladderJump.set();
  961.         }
  962.       break;
  963.     }
  964.     break;
  965.     
  966.       case CO_DN:
  967.     switch (stance) {
  968.     case CO_r:
  969.     case CO_up:
  970.     case CO_l:
  971.     case CO_climb:
  972.       if ((touching != CO_dn) || canClimb ||
  973.           (hanging.corner == CO_dn_R) || (hanging.corner == CO_dn_L))
  974.         command = IT_DN;
  975.       break;
  976.     case CO_center:
  977.       if (canClimb)
  978.         command = IT_DN;
  979.       break;
  980.     }
  981.     break;
  982.     
  983.       case CO_DN_L:
  984.     if (canClimb && touching != CO_dn && ladderJump.ready())
  985.       {
  986.         command = IT_DN;
  987.         break;
  988.       }
  989.     switch (stance) {
  990.     case CO_center:
  991.     case CO_dn:
  992.     case CO_up:
  993.       command = IT_L;
  994.       break;
  995.     case CO_l:
  996.       command = IT_DN;
  997.       break;
  998.     case CO_r:
  999.       command = IT_DN_L;
  1000.       break;
  1001.     case CO_climb:
  1002.       if (touching != CO_dn && ladderJump.ready())
  1003.         command = IT_DN;
  1004.       else
  1005.         {
  1006.           command = IT_L;
  1007.           ladderJump.set();
  1008.         }
  1009.       break;
  1010.     }
  1011.     break;
  1012.     
  1013.       case CO_L:
  1014.     switch (stance) {
  1015.     case CO_center:
  1016.     case CO_dn:
  1017.     case CO_r:
  1018.     case CO_up:
  1019.       if ((touching != CO_L) || (creature->is_sticky()))
  1020.         command = IT_L;
  1021.       break;
  1022.     case CO_climb:
  1023.       if ((touching != CO_L) || (creature->is_sticky()))
  1024.         {
  1025.           command = IT_UP_L;
  1026.           ladderJump.set();
  1027.         }
  1028.       break;
  1029.     };
  1030.     break;
  1031.     
  1032.       case CO_UP_L:
  1033.     if (canClimb && touching != CO_up && ladderJump.ready())
  1034.       {
  1035.         command = IT_UP;
  1036.         break;
  1037.       }
  1038.     switch (stance) {
  1039.     case CO_center:
  1040.     case CO_dn:
  1041.     case CO_up:
  1042.       command = IT_L;
  1043.       break;
  1044.     case CO_r:
  1045.       command = IT_UP;
  1046.       break;
  1047.     case CO_l:
  1048.       command = IT_UP_L;
  1049.       break;
  1050.     case CO_climb:
  1051.       if (touching != CO_up)
  1052.         command = IT_UP;
  1053.       else
  1054.         {
  1055.           command = IT_L;
  1056.           ladderJump.set();
  1057.         }
  1058.       break;
  1059.     };
  1060.     break;
  1061.     
  1062.       case CO_UP:
  1063.     switch (stance) {
  1064.     case CO_center:
  1065.     case CO_air:
  1066.     case CO_dn:
  1067.     case CO_r:
  1068.     case CO_l:
  1069.     case CO_climb:
  1070.       if ((touching != CO_up) || canClimb || 
  1071.           (hanging.corner == CO_up_R) || (hanging.corner == CO_up_L))
  1072.         command = IT_UP;
  1073.       break;
  1074.     };
  1075.     break;
  1076.     
  1077.       case CO_UP_R:
  1078.     if (canClimb && touching != CO_up && ladderJump.ready())
  1079.       {
  1080.         command = IT_UP;
  1081.         break;
  1082.       }
  1083.     switch (stance) {
  1084.     case CO_center:
  1085.     case CO_dn:
  1086.     case CO_up:
  1087.       command = IT_R;
  1088.       break;
  1089.     case CO_r:
  1090.     case CO_l:
  1091.       command = IT_UP_R;
  1092.       break;
  1093.     case CO_climb:
  1094.       if (touching != CO_up)
  1095.         command = IT_UP;
  1096.       else
  1097.         {
  1098.           command = IT_R;
  1099.           ladderJump.set();
  1100.         }
  1101.       break;
  1102.     };
  1103.     break;
  1104.       }
  1105.       
  1106.       if ((command == IT_NO_COMMAND) && !canClimb)
  1107.     command = IT_CENTER;
  1108.     }
  1109.   
  1110.   if (command != IT_NO_COMMAND)
  1111.     {
  1112.       physical->set_command(command);
  1113.       return True;
  1114.     }
  1115.  
  1116.   return False;
  1117. }
  1118.  
  1119.  
  1120.  
  1121. Boolean Machine::has_gun(PhysicalP p)
  1122. {
  1123.   for (int n = 0; n < p->get_weapons_num(); n++)
  1124.     {
  1125.       PhysicalP gun = p->get_weapon(n);
  1126.       if (gun && gun->is_gun())
  1127.     return True;
  1128.     }
  1129.   return False;
  1130. }
  1131.  
  1132.  
  1133.  
  1134. Boolean Machine::has_cutter(PhysicalP p)
  1135. {
  1136.   for (int n = 0; n < p->get_weapons_num(); n++)
  1137.     {
  1138.       PhysicalP w = p->get_weapon(n);
  1139.       if (w && w->is_cutter())
  1140.     return True;
  1141.     }
  1142.   return False;
  1143. }
  1144.  
  1145.  
  1146.  
  1147. Boolean Machine::has_shield(PhysicalP p)
  1148. {
  1149.   for (int n = 0; n < p->get_items_num(); n++)
  1150.     {
  1151.       PhysicalP w = p->get_item(n);
  1152.       if (w && w->is_shield())
  1153.     return True;
  1154.     }
  1155.   return False;
  1156. }
  1157.  
  1158.  
  1159.  
  1160. Boolean Machine::has_item(PhysicalP p,ClassId classId)
  1161. {
  1162.   for (int n = 0; n < p->get_items_num(); n++)
  1163.     {
  1164.       PhysicalP item = p->get_item(n);
  1165.       if (item && item->get_class_id() == classId)
  1166.     return True;
  1167.     }
  1168.   return False;
  1169. }
  1170.  
  1171.  
  1172.  
  1173. Boolean Machine::weapon_current_is_gun(PhysicalP p)
  1174. {
  1175.   PhysicalP weapon = p->get_weapon_current();
  1176.   return weapon && weapon->is_gun();
  1177. }
  1178.  
  1179.  
  1180.  
  1181. Boolean Machine::weapon_current_is_cutter(PhysicalP p)
  1182. {
  1183.   PhysicalP weapon = p->get_weapon_current();
  1184.   return weapon && weapon->is_cutter();
  1185. }
  1186.  
  1187.  
  1188.  
  1189. PhysicalP Machine::new_target_id(Boolean &isEnemy,PhysicalP p,
  1190.                  PhysicalP masterP)
  1191. {
  1192.   LocatorP locator = get_locator();
  1193.   
  1194.   PhysicalP nearby[OL_NEARBY_MAX];
  1195.   int nearbyNum;
  1196.   locator->get_nearby(nearby,nearbyNum,p,TARGET_RANGE);
  1197.  
  1198.   PhysicalP items[OL_NEARBY_MAX];
  1199.   int itemsNum = 0;
  1200.   PhysicalP enemies[OL_NEARBY_MAX];
  1201.   int enemiesNum = 0;
  1202.  
  1203.  
  1204.   // Pull out possible items and enemies from nearby.
  1205.   const IntelOptions &ops = get_intel_options();
  1206.   ClassId classId = p->get_class_id();
  1207.   for (int n = 0; n < nearbyNum; n++)
  1208.     {
  1209.       IntelP intel = nearby[n]->get_intel();
  1210.       
  1211.       if (nearby[n] != masterP &&
  1212.       nearby[n]->is_creature() && 
  1213.       nearby[n]->alive() && 
  1214.       intel && 
  1215.       // Don't want to have slaves of same master fighting each other.
  1216.       !(masterSet && !intel->is_human() && 
  1217.         ((MachineP)intel)->masterSet && 
  1218.         ((MachineP)intel)->masterIntelId == masterIntelId) &&
  1219.       !(ops.ignoreLemmings && nearby[n]->get_class_id() == A_Lemming) &&
  1220.       (intel->is_human() ||
  1221.        !(ops.classFriends && nearby[n]->get_class_id() == classId)))
  1222.     {
  1223.       enemies[enemiesNum] = nearby[n];
  1224.       enemiesNum++;
  1225.     }
  1226.       else if (!ops.ignoreItems &&
  1227.            p->is_user() && 
  1228.            nearby[n]->is_item() && 
  1229.            ((ItemP)nearby[n])->can_take())
  1230.     {
  1231.       items[itemsNum] = nearby[n];
  1232.       itemsNum++;
  1233.     }
  1234.     }
  1235.  
  1236.   if (enemiesNum)
  1237.     {
  1238.       PhysicalP target = enemies[Utils::choose(enemiesNum)];
  1239.       targetId = target->get_id();
  1240.       isEnemy = True;
  1241.       return target;
  1242.     }
  1243.   
  1244.   if (itemsNum)
  1245.     {
  1246.       PhysicalP target = items[Utils::choose(itemsNum)];
  1247.       targetId = target->get_id();
  1248.       isEnemy = False;
  1249.       return target;
  1250.     }
  1251.  
  1252.   return NULL;
  1253. }
  1254.  
  1255.  
  1256.  
  1257. Boolean Enemy::is_enemy()
  1258. {
  1259.   return True;
  1260. }
  1261.  
  1262.  
  1263.  
  1264. Boolean Neutral::is_enemy()
  1265. {
  1266.   return False;
  1267. }
  1268.  
  1269.  
  1270.  
  1271. LemmingIntel::LemmingIntel(WorldP w,LocatorP l,char *name,const Id &home_id)
  1272. :Neutral(w,l,name,NULL,ITnone)
  1273. {
  1274.   Timer oTimer(LADDER_JUMP_TIME);
  1275.   ladderJump = oTimer;
  1276.   homeId = home_id;
  1277. }
  1278.  
  1279.  
  1280.  
  1281. Boolean LemmingIntel::is_lemming_intel()
  1282. {
  1283.   return True;
  1284. }
  1285.  
  1286.  
  1287.  
  1288. void LemmingIntel::clock(PhysicalP p)
  1289. {
  1290.   assert(alive() && p->is_creature());
  1291.   LocatorP l = get_locator();
  1292.  
  1293.   PhysicalP home = l->lookup(homeId);
  1294.   assert(home);
  1295.   const Area &area = home->get_area();
  1296.   Pos middle = area.get_middle();
  1297.  
  1298.   move_pos(p,middle,ladderJump);
  1299.   ladderJump.clock();
  1300.  
  1301.   // NOTE: Skipping Machine::clock.
  1302.   Intel::clock(p);
  1303. }
  1304.